home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / packet / tf27bsrc / tfc.c < prev    next >
C/C++ Source or Header  |  1994-09-25  |  38KB  |  1,323 lines
  1. /**************************************************************************\
  2. *                                                                          *
  3. *                                                                          *
  4. *    *****                      *****                                      *
  5. *      *****                  *****                                        *
  6. *        *****              *****                                          *
  7. *          *****          *****                                            *
  8. *            *****      *****                                              *
  9. *              *****  *****                                                *
  10. *            *****      *****                                              *
  11. *          *****          *****          The Firmware.                     *
  12. *        *****              *****        Portable. Compatible.             *
  13. *      *****                  *****      Public Domain.                    *
  14. *    *****                      *****    By NORD><LINK.                    *
  15. *                                                                          *
  16. *                                                                          *
  17. *                                                                          *
  18. *    TFC.C   -   The Firmware, Teil 3, Utilities                           *
  19. *                                                                          *
  20. *    angelegt:      DC4OX                                                  *
  21. *    modifiziert:   DF7ZE / 01.01.90 / modul selmfl                        *
  22. *                   - bei voller heardliste ältesten eintrag überschreiben *
  23. *                   DL8ZAW, 27.04.91                                       *
  24. *                   frhmon(): [DAMA] bei DAMA-Master anzeigen              *
  25. *                                                                          *
  26. *                   DL8ZAW, 18.05.91                                       *
  27. *                   hputmb(): M7par=0: 7Bit-Maske verwenden                *
  28. *                                                                          *
  29. *                   DB2OS,  26.07.92                                       *
  30. *                   hputmb(): M7par=0: Kontrollzeichen als '^C' darstellen *
  31. *                             M7par=1: transparente 8-Bit Ausgabe.         *
  32. *                                                                          *
  33. *                   DB2OS,  18.10.92                                       *
  34. *                   hputmb(): BS|DEL Zeichenkorrektur ist dort bei AUSGABE *
  35. *                             überflüssig und stört BOXBIN im Terminal     *
  36. *                             8-Bit Modus.                                 *
  37. *                                                                          *
  38. *                   DB2OS,  17.7.92                                        *
  39. *                   invial(): Bei Monitor-Betrieb mit CALL-Filter die SSID *
  40. *                             nicht mehr berücksichtigen.                  *
  41. *                                                                          *
  42. *                   DB2OS,  23.11.93                                       *
  43. *                   M7par: 7Bit Ausgabe im Terminal Mode entfernt.         *
  44. *                                                                          *
  45. *                   DB2OS/DG2FEF, 13.08.94                                       *
  46. *                   frhmon(): l3/4 Klartextausgabe entfernt                *
  47. *                                                                          *
  48. \**************************************************************************/
  49.  
  50.  
  51.  
  52.  
  53.  
  54. /*                                                             Includes   */
  55. /**************************************************************************/
  56.  
  57. #include "all.h"         /* allgemeine Festlegungen                       */
  58. #include "tf.h"          /* Festlegungen/Datenstrukturen fuer TheFirmware */
  59. #include "l2.h"          /* Festlegungen/Datenstrukturen fuer den Level 2 */
  60. #include "tfext.h"       /* globale Variable / nicht int-Funktionen       */
  61.  
  62.  
  63.  
  64.  
  65.  
  66. /**************************************************************************\
  67. *                                                                          *
  68. * "initialize links"                                                       *
  69. *                                                                          *
  70. \**************************************************************************/
  71.  
  72. VOID inilks()
  73.   {
  74.     unsigned    n;
  75.     LNKBLK     *savelp;
  76.  
  77.     savelp = lnkpoi;
  78.     for (n = 0, lnkpoi = lnktbl; n < LINKNMBR; ++n, ++lnkpoi)
  79.       if (!lnkpoi->state) inilbl();
  80.     lnkpoi = savelp;
  81.   }
  82.  
  83.  
  84.  
  85.  
  86.  
  87. /**************************************************************************\
  88. *                                                                          *
  89. * "response invalid command"                                               *
  90. *                                                                          *
  91. \**************************************************************************/
  92.  
  93. VOID rspic(c)
  94.  
  95. unsigned c;
  96.  
  97.   {
  98.     rspini(HMRFMSG);
  99.     hputs("INVALID COMMAND: ");
  100.     hputcc(c);
  101.     rspexb();
  102.   }
  103.  
  104.  
  105.  
  106.  
  107.  
  108. /**************************************************************************\
  109. *                                                                          *
  110. * "response invalid extended command"                                      *
  111. *                                                                          *
  112. \**************************************************************************/
  113.  
  114. VOID rspiec(c)
  115.  
  116. unsigned c;
  117.  
  118.   {
  119.     rspini(HMRFMSG);
  120.     hputs("INVALID EXTENDED COMMAND: ");
  121.     hputcc(c);
  122.     rspexb();
  123.   }
  124.  
  125.  
  126.  
  127.  
  128.  
  129. /**************************************************************************\
  130. *                                                                          *
  131. * "response invalid value"                                                 *
  132. *                                                                          *
  133. \**************************************************************************/
  134.  
  135. VOID rspiv(value)
  136.  
  137. unsigned value;
  138.  
  139.   {
  140.     rspini(HMRFMSG);
  141.     hputs("INVALID VALUE: ");
  142.     hputud(value);
  143.     rspexb();
  144.   }
  145.  
  146.  
  147.  
  148.  
  149.  
  150. /**************************************************************************\
  151. *                                                                          *
  152. * "response invalid callsign"                                              *
  153. *                                                                          *
  154. \**************************************************************************/
  155.  
  156. VOID rspics()
  157.   {
  158.     rspini(HMRFMSG);
  159.     hputs("INVALID CALLSIGN");
  160.     rspexb();
  161.   }
  162.  
  163.  
  164.  
  165.  
  166.  
  167. /**************************************************************************\
  168. *                                                                          *
  169. * "response no source callsign"                                            *
  170. *                                                                          *
  171. \**************************************************************************/
  172.  
  173. VOID rspnsc()
  174.   {
  175.     rspini(HMRFMSG);
  176.     hputs("NO SOURCE CALLSIGN");
  177.     rspexb();
  178.   }
  179.  
  180.  
  181.  
  182.  
  183.  
  184. /**************************************************************************\
  185. *                                                                          *
  186. * "response already connected"                                             *
  187. *                                                                          *
  188. \**************************************************************************/
  189.  
  190. VOID rspalc()
  191.   {
  192.     hputs(" ALREADY CONNECTED");
  193.     rspexb();
  194.   }
  195.  
  196.  
  197.  
  198.  
  199.  
  200. /**************************************************************************\
  201. *                                                                          *
  202. * "response not while connected"                                           *
  203. *                                                                          *
  204. \**************************************************************************/
  205.  
  206. VOID rspnwc()
  207.   {
  208.     rspini(HMRFMSG);
  209.     hputs("NOT WHILE CONNECTED");
  210.     rspexb();
  211.   }
  212.  
  213.  
  214.  
  215.  
  216.  
  217. /**************************************************************************\
  218. *                                                                          *
  219. * "response line ignored"                                                  *
  220. *                                                                          *
  221. \**************************************************************************/
  222.  
  223. VOID rsplig()
  224.   {
  225.     rspini(HMRFMSG);
  226.     hputs("TNC BUSY - LINE IGNORED");
  227.     rspexb();
  228.   }
  229.  
  230.  
  231.  
  232.  
  233.  
  234. /**************************************************************************\
  235. *                                                                          *
  236. * "response invalid parameter"                                             *
  237. *                                                                          *
  238. \**************************************************************************/
  239.  
  240. VOID rspipa()
  241.   {
  242.     rspini(HMRFMSG);
  243.     hputs("INVALID PARAMETER");
  244.     rspexb();
  245.   }
  246.  
  247.  
  248.  
  249.  
  250.  
  251. /**************************************************************************\
  252. *                                                                          *
  253. * "frame header monitor"                                                   *
  254. *                                                                          *
  255. \**************************************************************************/
  256.  
  257. VOID frhmon(fbp)
  258.  
  259. MBHEAD *fbp;
  260.  
  261.   {
  262.     static char        id[L2IDLEN];
  263.     static unsigned    pid;
  264.     static unsigned    n;
  265.  
  266.  
  267.  
  268.     hputs("fm ");
  269.     hputid(rxfhdr + L2IDLEN);
  270.     hputs(" to ");
  271.     hputid(rxfhdr);
  272.     hputv(YES,rxfhdr + L2ILEN);
  273.     hputs(" ctl ");
  274.  
  275.     if (!(rxfctl & L2CNOIM))
  276.       hputc('I');
  277.     else
  278.       if (!(rxfctl & L2CNOSM))
  279.         switch ((rxfctl >> 2) & 0x3)
  280.           {
  281.             case 0  :   hputs("RR");    break;
  282.             case 1  :   hputs("RNR");   break;
  283.             case 2  :   hputs("REJ");   break;
  284.             default :
  285.               hputc('?');
  286.               hputby(rxfctl | rxfPF);
  287.               hputc('H');
  288.             break;
  289.           }
  290.       else
  291.         switch (rxfctl & 0xFF)
  292.           {
  293.             case L2CUI   :   hputs("UI");     break;
  294.             case L2CDM   :   hputs("DM");     break;
  295.             case L2CSABM :   hputs("SABM");   break;
  296.             case L2CDISC :   hputs("DISC");   break;
  297.             case L2CUA   :   hputs("UA");     break;
  298.             case L2CFRMR :
  299.               hputs("FRMR");
  300.               while (fbp->mbgc < fbp->mbpc) hputby(getchr(fbp));
  301.             break;
  302.             default      :
  303.               hputc('?');
  304.               hputby(rxfctl | rxfPF);
  305.               hputc('H');
  306.             break;
  307.           }
  308.  
  309.     if ((rxfctl & 0x3) != 3)
  310.       {
  311.         hputud((rxfctl >> 5) & 0x7);
  312.         if (!(rxfctl & L2CNOIM)) hputud((rxfctl >> 1) & 0x7);
  313.       }
  314.  
  315.     if (rxfPF != 0)
  316.       if (!rxfV2)
  317.         hputc('!');
  318.       else
  319.         hputc(rxfCR != 0 ? '+' : '-');
  320.     else
  321.       if (rxfV2 == YES)
  322.         hputc(rxfCR != 0 ? '^' : 'v');
  323.  
  324.     if (!(rxfctl & L2CNOIM) || rxfctl == L2CUI)
  325.       {
  326.         hputs(" pid ");
  327.         hputby(pid = fbp->mbgc < fbp->mbpc ? getchr(fbp) : 0);
  328.       }
  329.  
  330.     if ((rxfhdr[L2ILEN-1] & L2CDAMA) == 0)
  331.        hputs(" [DAMA]");
  332.  
  333.     if (stamp == 2)
  334.       {
  335.         hputs(" - ");
  336.         hputbt(&fbp->btime);
  337.       }
  338.   }
  339.  
  340.  
  341.  
  342.  
  343.  
  344. /**************************************************************************\
  345. *                                                                          *
  346. * "terminal mode response message buffer bell"                             *
  347. *                                                                          *
  348. \**************************************************************************/
  349.  
  350. VOID trpmbb(mbp)
  351.  
  352. MBHEAD *mbp;
  353.  
  354.   {
  355.     rwndmb(mbp);
  356.     hputs("\015\012* ");
  357.     hputmb(mbp);
  358.     if (stamp)
  359.       {
  360.         hputs(" - ");
  361.         hputbt(&mbp->btime);
  362.       }
  363.     hputs(" *\007\015\012");
  364.   }
  365.  
  366.  
  367.  
  368.  
  369.  
  370. /**************************************************************************\
  371. *                                                                          *
  372. * "host put message buffer"                                                *
  373. *                                                                          *
  374. \**************************************************************************/
  375. VOID hputmb(mbp)
  376. MBHEAD *mbp;
  377. {
  378.   static unsigned    ch;
  379.  
  380.   while (mbp->mbgc < mbp->mbpc)
  381.   {
  382.     ch = getchr(mbp) & 0xFF;         /* 8-Bit ASCII                 */
  383.     hputc(ch);                       /* transparent binary ausgeben */
  384.     if (ch == CR && Apar == YES )    /* Carriage Return + Linefeed  */
  385.       hputc(LF);
  386.   }
  387. }
  388.  
  389.  
  390.  
  391.  
  392.  
  393. /**************************************************************************\
  394. *                                                                          *
  395. * "response channel status"                                                *
  396. *                                                                          *
  397. \**************************************************************************/
  398.  
  399. VOID rspcs()
  400.   {
  401.     rspini(HMRSMSG);
  402.     if (!actch)
  403.       {
  404.         hputid(ch0id);
  405.         hputv(NO,ch0via);
  406.       }
  407.     else
  408.       if (lnkpoi->state != L2SDSCED)
  409.         {
  410.           hputid(lnkpoi->dstid);
  411.           hputv(NO,lnkpoi->viaidl);
  412.         }
  413.       else
  414.         hputs("CHANNEL NOT CONNECTED");
  415.     rspex();
  416.   }
  417.  
  418.  
  419.  
  420.  
  421.  
  422. /**************************************************************************\
  423. *                                                                          *
  424. * "host put via"                                                           *
  425. *                                                                          *
  426. \**************************************************************************/
  427.  
  428. VOID hputv(dmark,vial)
  429.  
  430. unsigned    dmark;
  431. char       *vial;
  432.  
  433.   {
  434.     if (*vial != '\0')
  435.       {
  436.         hputs(" via");
  437.         hputvl(dmark,vial);
  438.       }
  439.   }
  440.  
  441.  
  442.  
  443.  
  444.  
  445. /**************************************************************************\
  446. *                                                                          *
  447. * "host put via list"                                                      *
  448. *                                                                          *
  449. \**************************************************************************/
  450.  
  451. VOID hputvl(dmark,vial)
  452.  
  453. unsigned    dmark;
  454. char       *vial;
  455.  
  456.   {
  457.     while (*vial != '\0')
  458.       {
  459.         hputc(' ');
  460.         hputid(vial);
  461.         if (dmark == YES)
  462.           if ((vial[L2IDLEN - 1] & L2CH) != 0)
  463.             if (!vial[L2IDLEN] || !(vial[L2ILEN - 1] & L2CH))
  464.               {
  465.                 hputc('*');
  466.                 dmark = NO;
  467.               }
  468.         vial += L2IDLEN;
  469.       }
  470.   }
  471.  
  472.  
  473.  
  474.  
  475.  
  476. /**************************************************************************\
  477. *                                                                          *
  478. * "host put ID"                                                            *
  479. *                                                                          *
  480. \**************************************************************************/
  481.  
  482. VOID hputid(id)
  483.  
  484. char *id;
  485.  
  486.   {
  487.     static unsigned ssid;
  488.     static unsigned n;
  489.     static unsigned ch;
  490.  
  491.     for (n = 0; n < L2CALEN; ++n)
  492.       if ((ch = *id++ & 0xFF) > ' ')
  493.         hputc(ch);
  494.       else
  495.         if (ch < ' ')
  496.           {
  497.             hputc('^');
  498.             hputc(ch + '@');
  499.           }
  500.    if ((ssid = (*id >> 1) & 0xF) != 0)
  501.      {
  502.        hputc('-');
  503.        hputud(ssid);
  504.      }
  505.   }
  506.  
  507.  
  508.  
  509.  
  510.  
  511. /**************************************************************************\
  512. *                                                                          *
  513. * "response parameter"                                                     *
  514. *                                                                          *
  515. \**************************************************************************/
  516.  
  517. VOID rsppar(par)
  518.  
  519. unsigned par;
  520.  
  521.   {
  522.     rspini(HMRSMSG);
  523.     hputud(par);
  524.     rspex();
  525.   }
  526.  
  527.  
  528.  
  529.  
  530.  
  531. /**************************************************************************\
  532. *                                                                          *
  533. * "host put unsigned decimal"                                              *
  534. *                                                                          *
  535. \**************************************************************************/
  536.  
  537. VOID hputud(u)
  538.  
  539. unsigned u;
  540.  
  541.   {
  542.     static BOOLEAN    out;
  543.     static unsigned   div;
  544.     static unsigned   digit;
  545.     static unsigned   n;
  546.  
  547.     for (out = FALSE, div = 10000, n = 0; n < 5; ++n)
  548.       {
  549.         if ((digit = u/div) != 0 || out == TRUE || div == 1)
  550.           {
  551.             hputc(digit + '0');
  552.             out = TRUE;
  553.           }
  554.         u  %= div;
  555.         div /= 10;
  556.       }
  557.   }
  558.  
  559.  
  560.  
  561.  
  562.  
  563. /**************************************************************************\
  564. *                                                                          *
  565. * "host put buffer time"                                                   *
  566. *                                                                          *
  567. \**************************************************************************/
  568.  
  569.  
  570.  
  571. VOID hput2d(c)
  572.  
  573. char c;
  574.  
  575.   {
  576.     hputud((c & 0xff) / 10);
  577.     hputud((c & 0xff) % 10);
  578.   }
  579.  
  580.  
  581.  
  582. VOID hputbt(tbp)
  583.  
  584. TIMEBL *tbp;
  585.  
  586.   {
  587.     if (eudate)
  588.       {
  589.         hput2d(tbp->day);
  590.         hputc('.');
  591.         hput2d(tbp->month);
  592.         hputc('.');
  593.       }
  594.     else
  595.       {
  596.         hput2d(tbp->month);
  597.         hputc('/');
  598.         hput2d(tbp->day);
  599.         hputc('/');
  600.       }
  601.     hput2d(tbp->year);
  602.     hputc(' ');
  603.     hput2d(tbp->hour);
  604.     hputc(':');
  605.     hput2d(tbp->minute);
  606.     hputc(':');
  607.     hput2d(tbp->second);
  608.   }
  609.  
  610.  
  611.  
  612.  
  613.  
  614. /**************************************************************************\
  615. *                                                                          *
  616. * "host put byte"                                                          *
  617. *                                                                          *
  618. \**************************************************************************/
  619.  
  620. VOID hputby(byte)
  621.  
  622. unsigned byte;
  623.  
  624.   {
  625.     hputni(byte >> 4);
  626.     hputni(byte);
  627.   }
  628.  
  629.  
  630.  
  631.  
  632.  
  633. /**************************************************************************\
  634. *                                                                          *
  635. * "host put nibble"                                                        *
  636. *                                                                          *
  637. \**************************************************************************/
  638.  
  639. VOID hputni(nibble)
  640.  
  641. unsigned nibble;
  642.  
  643.   {
  644.     nibble &= 0xF;
  645.     if (nibble > 9) nibble += 7;
  646.     hputc(nibble + '0');
  647.   }
  648.  
  649.  
  650.  
  651.  
  652.  
  653. /**************************************************************************\
  654. *                                                                          *
  655. * "response init"                                                          *
  656. *                                                                          *
  657. \**************************************************************************/
  658.  
  659. VOID rspini(r)
  660.  
  661. unsigned r;
  662.  
  663.   {
  664.     if (!ishmod)
  665.       hputs("* ");
  666.     else
  667.       hmputr(r);
  668.   }
  669.  
  670.  
  671.  
  672.  
  673.  
  674. /**************************************************************************\
  675. *                                                                          *
  676. * "response success"                                                       *
  677. *                                                                          *
  678. \**************************************************************************/
  679.  
  680. VOID rspsuc()
  681.   {
  682.     if (ishmod == YES) hmputr(0);
  683.   }
  684.  
  685.  
  686.  
  687.  
  688.  
  689. /**************************************************************************\
  690. *                                                                          *
  691. * "host mode put response"                                                 *
  692. *                                                                          *
  693. \**************************************************************************/
  694.  
  695. VOID hmputr(r)
  696.  
  697. unsigned r;
  698.  
  699.   {
  700.     hputc(actch);
  701.     hputc(r);
  702.   }
  703.  
  704.  
  705.  
  706.  
  707.  
  708. /**************************************************************************\
  709. *                                                                          *
  710. * "response exit"                                                          *
  711. *                                                                          *
  712. \**************************************************************************/
  713.  
  714. VOID rspex()
  715.   {
  716.     if (!ishmod)
  717.       hputs(" *\015\012");
  718.     else
  719.       hputc(0);
  720.   }
  721.  
  722.  
  723.  
  724.  
  725.  
  726. /**************************************************************************\
  727. *                                                                          *
  728. * "response exit bell"                                                     *
  729. *                                                                          *
  730. \**************************************************************************/
  731.  
  732. VOID rspexb()
  733.   {
  734.     if (!ishmod)
  735.       hputs(" *\007\015\012");
  736.     else
  737.       hputc(0);
  738.   }
  739.  
  740.  
  741.  
  742.  
  743.  
  744. /**************************************************************************\
  745. *                                                                          *
  746. * "host carriage return linefeed"                                          *
  747. *                                                                          *
  748. \**************************************************************************/
  749.  
  750. VOID hcrlf()
  751.   {
  752.     hputs("\015\012");
  753.   }
  754.  
  755.  
  756.  
  757.  
  758.  
  759. /**************************************************************************\
  760. *                                                                          *
  761. * "host put string"                                                        *
  762. *                                                                          *
  763. \**************************************************************************/
  764.  
  765. VOID hputs(str)
  766.  
  767. char *str;
  768.  
  769.   {
  770.     while (*str != '\0') hputc(*str++);
  771.   }
  772.  
  773.  
  774.  
  775.  
  776.  
  777. /**************************************************************************\
  778. *                                                                          *
  779. * "host put control character"                                             *
  780. *                                                                          *
  781. \**************************************************************************/
  782.  
  783. VOID hputcc(c)
  784.  
  785. unsigned c;
  786.  
  787.   {
  788.     if (c >= ' ')
  789.       hputc(c);
  790.     else
  791.       {
  792.         hputc('^');
  793.         hputc(c + '@');
  794.       }
  795.   }
  796.  
  797.  
  798.  
  799.  
  800.  
  801. /**************************************************************************\
  802. *                                                                          *
  803. * "status to channel"                                                      *
  804. *                                                                          *
  805. \**************************************************************************/
  806.  
  807. VOID sttoch(msg)
  808.  
  809. unsigned msg;
  810.  
  811.   {
  812.     static char     *frmrp;
  813.     static MBHEAD   *mbp;
  814.  
  815.     putchr('(',mbp = allocb());
  816.     putudc((lnkpoi - lnktbl) + 1,mbp);
  817.     putstr(") ",mbp);
  818.     putstr(l2msgs[msg - 1],mbp);
  819.     putchr(' ',mbp);
  820.     putid(lnkpoi->dstid,mbp);
  821.     putv(NO,lnkpoi->viaidl,mbp);
  822.     if (msg == L2MFRMRF || msg == L2MFRMRT)
  823.       {
  824.         putstr(" (",mbp);
  825.         frmrp = lnkpoi->frmr;
  826.         putbyt(*frmrp++,mbp);
  827.         putbyt(*frmrp++,mbp);
  828.         putbyt(*frmrp++,mbp);
  829.         putchr(')',mbp);
  830.       }
  831.     stampb(&mbp->btime);
  832.     mbp->type = msg;
  833.     if (!ishmod && !Upar)
  834.       relink(mbp,statml.tail);
  835.     else
  836.       {
  837.         relink(mbp,chnlml[lnkpoi-lnktbl].tail);
  838.         chnlbc[lnkpoi-lnktbl] += mbp->mbpc;
  839.       }
  840.   }
  841.  
  842.  
  843.  
  844.  
  845.  
  846. /**************************************************************************\
  847. *                                                                          *
  848. * "put via ID's"                                                           *
  849. *                                                                          *
  850. \**************************************************************************/
  851.  
  852. VOID putv(dmark,vial,mbp)
  853.  
  854. unsigned    dmark;
  855. char       *vial;
  856. MBHEAD     *mbp;
  857.  
  858.   {
  859.     if (*vial != '\0')
  860.       {
  861.         putstr(" via",mbp);
  862.         while (*vial != '\0')
  863.           {
  864.             putchr(' ',mbp);
  865.             putid(vial,mbp);
  866.             if (dmark == YES)
  867.               if ((vial[L2IDLEN - 1] & L2CH) != 0)
  868.                 if ((!vial[L2IDLEN] || !(vial[L2ILEN - 1] & L2CH)))
  869.                   {
  870.                     putchr('*',mbp);
  871.                     dmark = NO;
  872.                   }
  873.             vial += L2IDLEN;
  874.           }
  875.       }
  876.   }
  877.  
  878.  
  879.  
  880.  
  881.  
  882. /**************************************************************************\
  883. *                                                                          *
  884. * "put ID"                                                                 *
  885. *                                                                          *
  886. \**************************************************************************/
  887.  
  888. VOID putid(id,mbp)
  889.  
  890. char     *id;
  891. MBHEAD   *mbp;
  892.  
  893.   {
  894.     static unsigned ssid;
  895.     static unsigned n;
  896.     static unsigned c;
  897.  
  898.     for (n = 0; n < L2CALEN; ++n)
  899.       if ((c = *id++ & 0xFF) > ' ')
  900.         putchr(c,mbp);
  901.       else
  902.         if (c < ' ')
  903.           {
  904.             putchr('^',mbp);
  905.             putchr(c + '@',mbp);
  906.           }
  907.     if ((ssid = (*id >> 1) & 0xF) != 0)
  908.       {
  909.         putchr('-',mbp);
  910.         putudc(ssid,mbp);
  911.       }
  912.   }
  913.  
  914.  
  915.  
  916.  
  917.  
  918. /**************************************************************************\
  919. *                                                                          *
  920. * "put unsigned decimal"                                                   *
  921. *                                                                          *
  922. \**************************************************************************/
  923.  
  924. VOID putudc(u,mbp)
  925.  
  926. unsigned    u;
  927. MBHEAD     *mbp;
  928.  
  929.   {
  930.     static BOOLEAN    out;
  931.     static unsigned   div;
  932.     static unsigned   digit;
  933.     static unsigned   n;
  934.  
  935.     for (out = FALSE, div = 10000, n = 0; n < 5; ++n)
  936.       {
  937.         if ((digit = u/div) != 0 || out == TRUE || div == 1)
  938.           {
  939.             putchr(digit + '0',mbp);
  940.             out = TRUE;
  941.           }
  942.         u %= div;
  943.         div /= 10;
  944.       }
  945.   }
  946.  
  947.  
  948.  
  949.  
  950.  
  951. /**************************************************************************\
  952. *                                                                          *
  953. * "put byte"                                                               *
  954. *                                                                          *
  955. \**************************************************************************/
  956.  
  957. VOID putbyt(byte,mbp)
  958.  
  959. unsigned    byte;
  960. MBHEAD     *mbp;
  961.  
  962.   {
  963.     putnib(byte >> 4,mbp);
  964.     putnib(byte,mbp);
  965.   }
  966.  
  967.  
  968.  
  969.  
  970.  
  971. /**************************************************************************\
  972. *                                                                          *
  973. * "put nibble"                                                             *
  974. *                                                                          *
  975. \**************************************************************************/
  976.  
  977. VOID putnib(nibble,mbp)
  978.  
  979. unsigned    nibble;
  980. MBHEAD     *mbp;
  981.  
  982.   {
  983.     nibble &= 0xF;
  984.     if (nibble > 9) nibble += 7;
  985.     putchr(nibble + '0',mbp);
  986.   }
  987.  
  988.  
  989.  
  990.  
  991.  
  992. /**************************************************************************\
  993. *                                                                          *
  994. * "put string"                                                             *
  995. *                                                                          *
  996. \**************************************************************************/
  997.  
  998. VOID putstr(str,mbp)
  999.  
  1000. char     *str;
  1001. MBHEAD   *mbp;
  1002.  
  1003.   {
  1004.     while (*str != '\0') putchr(*str++,mbp);
  1005.   }
  1006.  
  1007.  
  1008.  
  1009.  
  1010.  
  1011. /**************************************************************************\
  1012. *                                                                          *
  1013. * "buffer get parameter"                                                   *
  1014. *                                                                          *
  1015. \**************************************************************************/
  1016.  
  1017. unsigned bgetp()
  1018.   {
  1019.     static unsigned par;
  1020.  
  1021.     nxtnos();
  1022.     par = 0;
  1023.     while (incnt != 0 && *inbufp >= '0' && *inbufp <= '9')
  1024.       {
  1025.         --incnt;
  1026.         par *= 10;
  1027.         par += *inbufp++ - '0';
  1028.       }
  1029.     return (par);
  1030.   }
  1031.  
  1032.  
  1033.  
  1034.  
  1035.  
  1036. /**************************************************************************\
  1037. *                                                                          *
  1038. * "flagged validate callsign"                                              *
  1039. *                                                                          *
  1040. \**************************************************************************/
  1041.  
  1042. fvalca(check,call)
  1043.  
  1044. unsigned    check;
  1045. char       *call;
  1046.  
  1047.   {
  1048.     char       *lnpoi;
  1049.     char       *cpoi;
  1050.     unsigned    nmbn;
  1051.     unsigned    n;
  1052.     unsigned    c;
  1053.  
  1054.     if (*call == ' ') return(FALSE);
  1055.     if (!check) return(TRUE);
  1056.     for (nmbn = 0, n = 0, cpoi = call; n < L2CALEN; ++n, ++cpoi)
  1057.       {
  1058.         if ((c = *cpoi & 0xFF) == ' ') break;
  1059.         if (!(c >= 'A' && c <= 'Z'))
  1060.           if (c >= '0' && c <= '9')
  1061.             {
  1062.               ++nmbn;
  1063.               lnpoi = cpoi;
  1064.             }
  1065.           else
  1066.             return (ERROR);
  1067.       }
  1068.     if (    cpoi - call < 4
  1069.          || !nmbn
  1070.          || nmbn > 2
  1071.          || lnpoi == call
  1072.          || cpoi - 1 == lnpoi
  1073.        )
  1074.       return (ERROR);
  1075.     else
  1076.       return (TRUE);
  1077.   }
  1078.  
  1079.  
  1080.  
  1081.  
  1082.  
  1083. /**************************************************************************\
  1084. *                                                                          *
  1085. * "stamp buffer"                                                           *
  1086. *                                                                          *
  1087. \**************************************************************************/
  1088.  
  1089. VOID stampb(dtp)
  1090.  
  1091. char *dtp;
  1092.  
  1093.   {
  1094.     static unsigned   n;
  1095.     static char      *stp;
  1096.  
  1097.     for (stp = (char *)&time, n = 0; n < 6; ++n) *dtp++ = *stp++;
  1098.   }
  1099.  
  1100.  
  1101.  
  1102.  
  1103.  
  1104. /**************************************************************************\
  1105. *                                                                          *
  1106. * "select monitor frame list"                                              *
  1107. *                                                                          *
  1108. \**************************************************************************/
  1109.  
  1110. VOID selmfl()
  1111.   {
  1112.     static MBHEAD     *fbp;
  1113.  
  1114.  
  1115.     while ((fbp = monfl.head) != &monfl)
  1116.       {
  1117.         unlink(fbp);
  1118.         stampb(&fbp->btime);
  1119.         if (ismonf(fbp) == YES)
  1120.           relink(fbp,smonfl.tail);
  1121.         else
  1122.           dealmb(fbp);
  1123.  
  1124.       } /* end  while ((fbp = monfl.head) != &monfl) */
  1125.   }
  1126.  
  1127.  
  1128.  
  1129. /**************************************************************************\
  1130. *                                                                          *
  1131. * "insert into heard - list"                                               *
  1132. *  return new number of entries                                            *
  1133. *                                                                          *
  1134. \**************************************************************************/
  1135.  
  1136.  
  1137. /**************************************************************************\
  1138. *                                                                          *
  1139. * "is monitor frame"                                                       *
  1140. *                                                                          *
  1141. \**************************************************************************/
  1142.  
  1143. BOOLEAN ismonf(fbp)
  1144.  
  1145. MBHEAD *fbp;
  1146.  
  1147.   {
  1148.     if (!actch || !lnkpoi->state || (Mpar & MONC) != NO)
  1149.       {
  1150.         takfhd(fbp);
  1151.         if (    !(rxfctl & L2CNOIM) && (Mpar & MONI) != 0
  1152.              || (rxfctl & 3) == 1 && (Mpar & MONS) != 0
  1153.              || ((rxfctl & 3) == 3 && rxfctl != L2CUI) && (Mpar & MONS) != 0
  1154.              || rxfctl == L2CUI && (Mpar & MONU) != 0
  1155.            )
  1156.           {
  1157.             if (mftsel != 0)
  1158.               if (    invial(mftidl,rxfhdr + L2IDLEN) == YES
  1159.                    || invial(mftidl,rxfhdr) == YES
  1160.                  )
  1161.                 {
  1162.                   if (mftsel == 2) return (NO);
  1163.                 }
  1164.               else
  1165.                 {
  1166.                  if (mftsel == 1) return (NO);
  1167.                 }
  1168.             return (YES);
  1169.           }
  1170.       }
  1171.     return (NO);
  1172.   }
  1173.  
  1174.  
  1175.  
  1176.  
  1177.  
  1178. /**************************************************************************\
  1179. *                                                                          *
  1180. * "message buffer count"                                                   *
  1181. *                                                                          *
  1182. \**************************************************************************/
  1183.  
  1184. unsigned mbcnt(msgl,select)
  1185.  
  1186. LHEAD      *msgl;
  1187. unsigned    select;
  1188.  
  1189.   {
  1190.     static unsigned    count;
  1191.     static MBHEAD     *mb;
  1192.  
  1193.     for (count = 0, mb = msgl->head; mb != msgl; mb = mb->nextmh)
  1194.       if (    select == MBALL
  1195.            || select == MBINFO    &&  mb->type == MBINFO
  1196.            || select == MBSTATUS  &&  mb->type != MBINFO
  1197.          ) ++count;
  1198.      return (count);
  1199.    }
  1200.  
  1201.  
  1202.  
  1203.  
  1204.  
  1205. /**************************************************************************\
  1206. *                                                                          *
  1207. * "select message buffer"                                                  *
  1208. *                                                                          *
  1209. \**************************************************************************/
  1210.  
  1211. MBHEAD *selmb(msgl,select)
  1212.  
  1213. LHEAD      *msgl;
  1214. unsigned    select;
  1215.  
  1216.   {
  1217.     static MBHEAD *mb;
  1218.  
  1219.     for (mb = msgl->head; mb != msgl; mb = mb->nextmh)
  1220.       if (    select == MBALL
  1221.            || select == MBINFO    &&  mb->type == MBINFO
  1222.            || select == MBSTATUS  &&  mb->type != MBINFO
  1223.          )
  1224.         return(mb);
  1225.     return (NULL);
  1226.   }
  1227.  
  1228.  
  1229.  
  1230.  
  1231.  
  1232. /**************************************************************************\
  1233. *                                                                          *
  1234. * "in via list"     Für CALL-Filter im Monitor-Betrieb.                    *
  1235. *                                                                          *
  1236. \**************************************************************************/
  1237.  
  1238. BOOLEAN invial(vial,id)
  1239.  
  1240. char *vial;
  1241. char *id;
  1242.  
  1243.   {
  1244.     while (*vial != '\0')
  1245.       if (cmpcal(vial,id) == TRUE)  /* Nur CALL, nicht SSID vergleichen */
  1246.         return (TRUE);
  1247.       else
  1248.         vial += L2IDLEN;
  1249.     return (FALSE);
  1250.   }
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256. /**************************************************************************\
  1257. *                                                                          *
  1258. * "next no space"                                                          *
  1259. *                                                                          *
  1260. \**************************************************************************/
  1261.  
  1262. BOOLEAN nxtnos()
  1263.   {
  1264.     while (incnt != 0 && *inbufp == ' ')
  1265.       {
  1266.         ++inbufp;
  1267.         --incnt;
  1268.       }
  1269.     return (incnt != 0);
  1270.   }
  1271.  
  1272.  
  1273.  
  1274.  
  1275.  
  1276. /**************************************************************************\
  1277. *                                                                          *
  1278. * "neighbor port"                                                          *
  1279. *                                                                          *
  1280. \**************************************************************************/
  1281.  
  1282. unsigned nbrprt(id)
  1283.  
  1284. char *id;
  1285.  
  1286.   {
  1287.     return(HDLCPORT);
  1288.   }
  1289.  
  1290.  
  1291.  
  1292.  
  1293.  
  1294. /**************************************************************************\
  1295. *                                                                          *
  1296. * "is warm reset"                                                          *
  1297. *                                                                          *
  1298. \**************************************************************************/
  1299.  
  1300. BOOLEAN iswarm()
  1301.   {
  1302.     return (magicn == MAGIC);
  1303.   }
  1304.  
  1305.  
  1306.  
  1307.  
  1308.  
  1309. /**************************************************************************\
  1310. *                                                                          *
  1311. * "timer"                                                                  *
  1312. *                                                                          *
  1313. \**************************************************************************/
  1314.  
  1315. VOID timer()
  1316.   {
  1317.     ++ticks;
  1318.   }
  1319.  
  1320.  
  1321.  
  1322. /* Ende von TFC.C */
  1323.